package com.thrid.party.codec.demo;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.node.ObjectNode;

public class CmdProcess {

    //private String identifier = "123";
    private String msgType = "";
    private String serviceId = "Switch";
    private String cmd = "SET_DEVICE_LEVEL";
    private int hasMore = 0;
    private int errcode = 0;
    private String request = "";
    private int mid = 0;
    private String time;
    private JsonNode paras;
    private int codeID;
    private String modelNum;
    private String cmdCode;
    private int version;

    public CmdProcess() {
    }

    public CmdProcess(ObjectNode input) {

        try {
            // this.identifier = input.get("identifier").asText();
            this.msgType = input.get("msgType").asText();
            /*
            平台收到设备上报消息，编码ACK
            {
                "identifier":"0",
                "msgType":"cloudRsp",
                "request": ***,//设备上报的码流
                "errcode":0,
                "hasMore":0
            }
            * */
            if (msgType.equals("cloudRsp")) {
                //在此组装ACK的值
                this.errcode = input.get("errcode").asInt();
                this.hasMore = input.get("hasMore").asInt();
                this.request = input.get("request").asText();
            } else {
            /*
            平台下发命令到设备，输入
            {
                "identifier":0,
                "msgType":"cloudReq",
                "serviceId":"WaterMeter",
                "cmd":"SET_DEVICE_LEVEL",
                "paras":{"value":"20"},
                "hasMore":0

            }
            * */
                //此处需要考虑兼容性，如果没有传mId，则不对其进行编码
                if (input.get("mid") != null) {
                    this.mid = input.get("mid").intValue();
                }
                this.cmd = input.get("cmd").asText();
                this.paras = input.get("paras");
                this.hasMore = input.get("hasMore").asInt();
                this.serviceId = input.get("serviceId").asText();
                this.modelNum = paras.get("modelNum").asText();
                this.time = paras.get("timeff").asText();
                this.codeID = paras.get("codeID").asInt();
                this.cmdCode = paras.get("cmdCode").asText();
                this.version = paras.get("version").asInt();
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public byte[] toByte() {
        try {
            if (this.msgType.equals("cloudReq")) {
                /*
                应用服务器下发的控制命令，本例只有一条控制命令：SET_DEVICE_LEVEL
                如果有其他控制命令，增加判断即可。
                * */
                if (cmdCode.equals("selfOpenDegreeReq")) {
                    byte[] byteRead = new byte[38];
                    byteRead[0] = (byte) 0x26;
                    byteRead[1] = (byte) 0x04;
                    if (Utilty.getInstance().isValidofMid(mid)) {
                        byte[] byteMid = new byte[2];
                        byteMid = Utilty.getInstance().int2Bytes(mid, 2);
                        byteRead[2] = byteMid[0];
                        byteRead[3] = byteMid[1];
                    }
                    byte[] byte1 = Utilty.getInstance().str2Bytes(modelNum);
                    byteRead[4] = byte1[0];
                    byteRead[5] = byte1[1];
                    byteRead[6] = byte1[2];
                    byteRead[7] = byte1[3];
                    byteRead[8] = byte1[4];
                    byteRead[9] = byte1[5];
                    byteRead[10] = byte1[6];
                    byteRead[11] = byte1[7];
                    byteRead[12] = byte1[8];
                    byteRead[13] = byte1[9];
                    byteRead[14] = byte1[10];
                    byteRead[15] = byte1[11];
                    byteRead[16] = byte1[12];
                    byteRead[17] = byte1[13];
                    byteRead[18] = byte1[14];
                    byteRead[19] = byte1[15];
                    byte[] byte2 = Utilty.getInstance().time2Bytes(time, 6);
                    byteRead[20] = byte2[0];
                    byteRead[21] = byte2[1];
                    byteRead[22] = byte2[2];
                    byteRead[23] = byte2[3];
                    byteRead[24] = byte2[4];
                    byteRead[25] = byte2[5];
                    byte[] byteID = Utilty.getInstance().int2Bytes(codeID, 3);
                    byteRead[26] = byteID[0];
                    byteRead[27] = byteID[1];
                    byteRead[28] = byteID[2];
                    byteRead[29] = (byte) 0x01;
                    byteRead[30] = (byte) 0x01;
                    byteRead[31] = (byte) 0x00;
                    float openDegreeValue = paras.get("openDegreeValue").floatValue();
                    byte[] b = Utilty.getInstance().float2Bytes(openDegreeValue, 3);
                    byteRead[32] = b[0];
                    byteRead[33] = b[1];
                    byteRead[34] = b[2];
                    byteRead[35] = (byte) version;
                    byteRead[36] = Utilty.getInstance().getCs(byteRead, 0, 36);
                    byteRead[37] = (byte) 0x16;
                    return byteRead;
                } else if (cmdCode.equals("autoOpenDegreeReq")) {
                    byte[] byteRead1 = new byte[50];
                    byteRead1[0] = (byte) 0x32;
                    byteRead1[1] = (byte) 0x06;
                    if (Utilty.getInstance().isValidofMid(mid)) {
                        byte[] byteMid = new byte[2];
                        byteMid = Utilty.getInstance().int2Bytes(mid, 2);
                        byteRead1[2] = byteMid[0];
                        byteRead1[3] = byteMid[1];
                    }
                    byte[] byte3 = Utilty.getInstance().str2Bytes(modelNum);
                    byteRead1[4] = byte3[0];
                    byteRead1[5] = byte3[1];
                    byteRead1[6] = byte3[2];
                    byteRead1[7] = byte3[3];
                    byteRead1[8] = byte3[4];
                    byteRead1[9] = byte3[5];
                    byteRead1[10] = byte3[6];
                    byteRead1[11] = byte3[7];
                    byteRead1[12] = byte3[8];
                    byteRead1[13] = byte3[9];
                    byteRead1[14] = byte3[10];
                    byteRead1[15] = byte3[11];
                    byteRead1[16] = byte3[12];
                    byteRead1[17] = byte3[13];
                    byteRead1[18] = byte3[14];
                    byteRead1[19] = byte3[15];
                    byte[] byte4 = Utilty.getInstance().time2Bytes(time, 6);
                    byteRead1[20] = byte4[0];
                    byteRead1[21] = byte4[1];
                    byteRead1[22] = byte4[2];
                    byteRead1[23] = byte4[3];
                    byteRead1[24] = byte4[4];
                    byteRead1[25] = byte4[5];
                    byte[] byteID1 = Utilty.getInstance().int2Bytes(codeID, 3);
                    byteRead1[26] = byteID1[0];
                    byteRead1[27] = byteID1[1];
                    byteRead1[28] = byteID1[2];
                    byteRead1[29] = (byte) 0x01;
                    byteRead1[30] = (byte) 0x02;
                    byteRead1[31] = (byte) 0x00;
                    float openDegreeValue1 = paras.get("openDegreeValue1").floatValue();
                    byte[] b1 = Utilty.getInstance().float2Bytes(openDegreeValue1, 3);
                    byteRead1[32] = b1[0];
                    byteRead1[33] = b1[1];
                    byteRead1[34] = b1[2];
                    float openDegreeValue2 = paras.get("openDegreeValue2").floatValue();
                    byte[] b2 = Utilty.getInstance().float2Bytes(openDegreeValue2, 3);
                    byteRead1[35] = b2[0];
                    byteRead1[36] = b2[1];
                    byteRead1[37] = b2[2];
                    float openDegreeValue3 = paras.get("openDegreeValue3").floatValue();
                    byte[] b3 = Utilty.getInstance().float2Bytes(openDegreeValue3, 3);
                    byteRead1[38] = b3[0];
                    byteRead1[39] = b3[1];
                    byteRead1[40] = b3[2];
                    float openDegreeValue4 = paras.get("openDegreeValue4").floatValue();
                    byte[] b4 = Utilty.getInstance().float2Bytes(openDegreeValue4, 3);
                    byteRead1[41] = b4[0];
                    byteRead1[42] = b4[1];
                    byteRead1[43] = b4[2];
                    float openDegreeValue5 = paras.get("openDegreeValue5").floatValue();
                    byte[] b5 = Utilty.getInstance().float2Bytes(openDegreeValue5, 3);
                    byteRead1[44] = b5[0];
                    byteRead1[45] = b5[1];
                    byteRead1[46] = b5[2];
                    byteRead1[47] = (byte) version;
                    byteRead1[48] = Utilty.getInstance().getCs(byteRead1, 0, 48);
                    byteRead1[49] = (byte) 0x16;
                    return byteRead1;
                } else if (cmdCode.equals("setDeviceReq")) {
                    byte[] byteRead2 = new byte[44];
                    byteRead2[0] = (byte) 0x2C;
                    byteRead2[1] = (byte) 0x08;
                    if (Utilty.getInstance().isValidofMid(mid)) {
                        byte[] byteMid = new byte[2];
                        byteMid = Utilty.getInstance().int2Bytes(mid, 2);
                        byteRead2[2] = byteMid[0];
                        byteRead2[3] = byteMid[1];
                    }
                    byte[] byte5 = Utilty.getInstance().str2Bytes(modelNum);
                    byteRead2[4] = byte5[0];
                    byteRead2[5] = byte5[1];
                    byteRead2[6] = byte5[2];
                    byteRead2[7] = byte5[3];
                    byteRead2[8] = byte5[4];
                    byteRead2[9] = byte5[5];
                    byteRead2[10] = byte5[6];
                    byteRead2[11] = byte5[7];
                    byteRead2[12] = byte5[8];
                    byteRead2[13] = byte5[9];
                    byteRead2[14] = byte5[10];
                    byteRead2[15] = byte5[11];
                    byteRead2[16] = byte5[12];
                    byteRead2[17] = byte5[13];
                    byteRead2[18] = byte5[14];
                    byteRead2[19] = byte5[15];
                    byte[] byte6 = Utilty.getInstance().time2Bytes(time, 6);
                    byteRead2[20] = byte6[0];
                    byteRead2[21] = byte6[1];
                    byteRead2[22] = byte6[2];
                    byteRead2[23] = byte6[3];
                    byteRead2[24] = byte6[4];
                    byteRead2[25] = byte6[5];
                    byte[] byteID2 = Utilty.getInstance().int2Bytes(codeID, 3);
                    byteRead2[26] = byteID2[0];
                    byteRead2[27] = byteID2[1];
                    byteRead2[28] = byteID2[2];
                    byteRead2[29] = (byte) 0x02;
                    byteRead2[30] = (byte) 0x03;
                    byteRead2[31] = (byte) 0x00;
                    float frequency = paras.get("frequencyValue").floatValue();
                    byte[] b6 = Utilty.getInstance().float2Bytes(frequency, 3);
                    byteRead2[32] = b6[0];
                    byteRead2[33] = b6[1];
                    byteRead2[34] = b6[2];
                    float alarm = paras.get("alarmValue").floatValue();
                    byte[] b7 = Utilty.getInstance().float2Bytes(alarm, 3);
                    byteRead2[35] = b7[0];
                    byteRead2[36] = b7[1];
                    byteRead2[37] = b7[2];
                    float calibration = paras.get("calibrationValue").floatValue();
                    byte[] b8 = Utilty.getInstance().float2Bytes(calibration, 3);
                    byteRead2[38] = b8[0];
                    byteRead2[39] = b8[1];
                    byteRead2[40] = b8[2];
                    byteRead2[41] = (byte) version;
                    byteRead2[42] = Utilty.getInstance().getCs(byteRead2, 0, 42);
                    byteRead2[43] = (byte) 0x16;
                    return byteRead2;
                } else if (cmdCode.equals("timeReq")) {
                    byte[] byteRead3 = new byte[41];
                    byteRead3[0] = (byte) 0x29;
                    byteRead3[1] = (byte) 0x0A;
                    if (Utilty.getInstance().isValidofMid(mid)) {
                        byte[] byteMid = new byte[2];
                        byteMid = Utilty.getInstance().int2Bytes(mid, 2);
                        byteRead3[2] = byteMid[0];
                        byteRead3[3] = byteMid[1];
                    }
                    byte[] byte7 = Utilty.getInstance().str2Bytes(modelNum);
                    byteRead3[4] = byte7[0];
                    byteRead3[5] = byte7[1];
                    byteRead3[6] = byte7[2];
                    byteRead3[7] = byte7[3];
                    byteRead3[8] = byte7[4];
                    byteRead3[9] = byte7[5];
                    byteRead3[10] = byte7[6];
                    byteRead3[11] = byte7[7];
                    byteRead3[12] = byte7[8];
                    byteRead3[13] = byte7[9];
                    byteRead3[14] = byte7[10];
                    byteRead3[15] = byte7[11];
                    byteRead3[16] = byte7[12];
                    byteRead3[17] = byte7[13];
                    byteRead3[18] = byte7[14];
                    byteRead3[19] = byte7[15];
                    byte[] byte8 = Utilty.getInstance().time2Bytes(time, 6);
                    byteRead3[20] = byte8[0];
                    byteRead3[21] = byte8[1];
                    byteRead3[22] = byte8[2];
                    byteRead3[23] = byte8[3];
                    byteRead3[24] = byte8[4];
                    byteRead3[25] = byte8[5];
                    byte[] byteID3 = Utilty.getInstance().int2Bytes(codeID, 3);
                    byteRead3[26] = byteID3[0];
                    byteRead3[27] = byteID3[1];
                    byteRead3[28] = byteID3[2];
                    byteRead3[29] = (byte) 0x03;
                    byteRead3[30] = (byte) 0x05;
                    byteRead3[31] = (byte) 0x00;
                    String timeValue = paras.get("timeValue").asText();
                    byte[] b9 = Utilty.getInstance().time2Bytes(timeValue, 6);
                    byteRead3[32] = b9[0];
                    byteRead3[33] = b9[1];
                    byteRead3[34] = b9[2];
                    byteRead3[35] = b9[3];
                    byteRead3[36] = b9[4];
                    byteRead3[37] = b9[5];
                    byteRead3[38] = (byte) version;
                    byteRead3[39] = Utilty.getInstance().getCs(byteRead3, 0, 39);
                    byteRead3[40] = (byte) 0x16;
                    return byteRead3;
                } else if (cmdCode.equals("temperatureRsp")) {
                    byte[] byteRead4 = new byte[38];
                    byteRead4[0] = (byte) 0x26;
                    byteRead4[1] = (byte) 0x0C;
                    if (Utilty.getInstance().isValidofMid(mid)) {
                        byte[] byteMid = new byte[2];
                        byteMid = Utilty.getInstance().int2Bytes(mid, 2);
                        byteRead4[2] = byteMid[0];
                        byteRead4[3] = byteMid[1];
                    }
                    byte[] byte9 = Utilty.getInstance().str2Bytes(modelNum);
                    byteRead4[4] = byte9[0];
                    byteRead4[5] = byte9[1];
                    byteRead4[6] = byte9[2];
                    byteRead4[7] = byte9[3];
                    byteRead4[8] = byte9[4];
                    byteRead4[9] = byte9[5];
                    byteRead4[10] = byte9[6];
                    byteRead4[11] = byte9[7];
                    byteRead4[12] = byte9[8];
                    byteRead4[13] = byte9[9];
                    byteRead4[14] = byte9[10];
                    byteRead4[15] = byte9[11];
                    byteRead4[16] = byte9[12];
                    byteRead4[17] = byte9[13];
                    byteRead4[18] = byte9[14];
                    byteRead4[19] = byte9[15];
                    byte[] byte10 = Utilty.getInstance().time2Bytes(time, 6);
                    byteRead4[20] = byte10[0];
                    byteRead4[21] = byte10[1];
                    byteRead4[22] = byte10[2];
                    byteRead4[23] = byte10[3];
                    byteRead4[24] = byte10[4];
                    byteRead4[25] = byte10[5];
                    byte[] byteID4 = Utilty.getInstance().int2Bytes(codeID, 3);
                    byteRead4[26] = byteID4[0];
                    byteRead4[27] = byteID4[1];
                    byteRead4[28] = byteID4[2];
                    byteRead4[29] = (byte) 0x04;
                    byteRead4[30] = (byte) 0x04;
                    byteRead4[31] = (byte) 0x00;
                    float temperature = paras.get("temperatureValue").floatValue();
                    byte[] b10 = Utilty.getInstance().float2Bytes(temperature, 3);
                    byteRead4[32] = b10[0];
                    byteRead4[33] = b10[1];
                    byteRead4[34] = b10[2];
                    byteRead4[35] = (byte) version;
                    byteRead4[36] = Utilty.getInstance().getCs(byteRead4, 0, 36);
                    byteRead4[37] = (byte) 0x16;
                    return byteRead4;
                }
            }

            /*
            平台收到设备的上报数据，根据需要编码ACK，对设备进行响应，如果此处返回null，表示不需要对设备响应。
            * */
            else if (this.msgType.equals("cloudRsp")) {
                byte[] ack = new byte[5];
                ack[0] = (byte) 0x05;
                ack[1] = (byte) 0xFF;
                ack[2] = (byte) this.errcode;
                ack[3] = (byte) this.hasMore;
                ack[4] = (byte) this.mid;
                return ack;
            }
            return null;
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
            return null;
        }
    }

}
